using UnityEngine;
using System.Collections.Generic;
using GG.Tool;

[RequireComponent(typeof(PolygonCollider2D))]
public class PermanentColliderVisualizer : MonoBehaviour
{
    [Header("===========可视化参数设置===========")]
    [ChineseName("边框粗细")]
    public float lineThickness = 2f;
    [ChineseName("在游戏中渲染")]
    public bool showInGameView = false;
    [ChineseName("渲染边界")]
    public bool useLineRenderer = false;//是否
    
    [SerializeField,ChineseName("可视化边框材质")]private Material sharedMaterial;
    
    private PolygonCollider2D polygonCollider;
    private List<Vector3> worldPoints = new List<Vector3>();
    private LineRenderer lineRenderer;
    private bool isRuntime;
    
    void OnValidate()
    {
        if (polygonCollider == null)
            polygonCollider = GetComponent<PolygonCollider2D>();
        
        UpdateWorldPoints();
        
        // 在编辑模式下安全地配置LineRenderer
        if (useLineRenderer && Application.isEditor && !Application.isPlaying)
        {
            SafeSetupLineRenderer();
        }
    }
    
    void Awake()
    {
        polygonCollider = GetComponent<PolygonCollider2D>();
        isRuntime = Application.isPlaying;
        UpdateWorldPoints();
        
        if (useLineRenderer)
        {
            SetupLineRenderer();
        }
    }
    
    void UpdateWorldPoints()
    {
        if (polygonCollider == null || polygonCollider.pathCount == 0) 
            return;
        
        worldPoints.Clear();
        
        Vector2[] path = polygonCollider.GetPath(0);
        foreach (Vector2 point in path)
        {
            worldPoints.Add(transform.TransformPoint(point));
        }
        
        if (path.Length > 1)
        {
            worldPoints.Add(transform.TransformPoint(path[0]));
        }
    }
    
    void OnDrawGizmos()
    {
        if (!showInGameView && isRuntime)
            return;
        
        if (polygonCollider == null || worldPoints.Count < 2)
            return;
        
        // 只在未使用LineRenderer时绘制Gizmos
        if (!useLineRenderer)
        {
            for (int i = 0; i < worldPoints.Count - 1; i++)
            {
                Gizmos.DrawLine(worldPoints[i], worldPoints[i + 1]);
            }
        }
    }
    
    void OnDrawGizmosSelected()
    {
        if (polygonCollider == null || worldPoints.Count < 2 || useLineRenderer)
            return;
        for (int i = 0; i < worldPoints.Count - 1; i++)
        {
            DrawThickLine(worldPoints[i], worldPoints[i + 1], lineThickness);
        }
    }
    
    private void SafeSetupLineRenderer()
    {
        if (lineRenderer == null)
        {
            lineRenderer = GetComponent<LineRenderer>();
            if (lineRenderer == null)
            {
                lineRenderer = gameObject.AddComponent<LineRenderer>();
            }
        }
        
        // 在编辑模式下使用共享材质
        if (sharedMaterial == null)
        {
            Shader shader = Shader.Find("Sprites/Default");
            if (shader != null)
            {
                sharedMaterial = new Material(shader);
                sharedMaterial.hideFlags = HideFlags.DontSave; // 防止材质泄漏
            }
        }
        
        if (sharedMaterial != null)
        {
            lineRenderer.sharedMaterial = sharedMaterial;
        }
        
        ConfigureLineRenderer();
    }
    
    private void SetupLineRenderer()
    {
        if (lineRenderer == null)
        {
            lineRenderer = GetComponent<LineRenderer>();
            if (lineRenderer == null)
            {
                lineRenderer = gameObject.AddComponent<LineRenderer>();
            }
        }
        
        // 运行时创建实例材质
        if (isRuntime)
        {
            // Shader shader = Shader.Find("Sprites/Default");
            // if (shader != null)
            // {
            //     Material runtimeMaterial = new Material(shader);
            //     runtimeMaterial.color = outlineColor;
            //     lineRenderer.material = runtimeMaterial;
            // }
        }
        else
        {
            // 编辑模式下使用共享材质
            if (sharedMaterial == null)
            {
                Shader shader = Shader.Find("Sprites/Default");
                if (shader != null)
                {
                    sharedMaterial = new Material(shader);
                    sharedMaterial.hideFlags = HideFlags.DontSave;
                }
            }
            
            if (sharedMaterial != null)
            {
                lineRenderer.sharedMaterial = sharedMaterial;
            }
        }
        
        ConfigureLineRenderer();
        UpdateLineRendererPoints();
    }
    
    private void ConfigureLineRenderer()
    {
        if (lineRenderer == null) return;
        
        lineRenderer.startWidth = lineThickness;
        lineRenderer.endWidth = lineThickness;
        lineRenderer.loop = true;
        lineRenderer.useWorldSpace = true;
        lineRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
        lineRenderer.receiveShadows = false;
    }
    
    private void UpdateLineRendererPoints()
    {
        if (lineRenderer == null || worldPoints.Count == 0) 
            return;
        
        lineRenderer.positionCount = worldPoints.Count;
        lineRenderer.SetPositions(worldPoints.ToArray());
    }
    
    private void DrawThickLine(Vector3 start, Vector3 end, float width)
    {
        Camera camera = Camera.current;
        if (camera == null) return;
        
        Vector3 direction = (end - start).normalized;
        Vector3 perpendicular = Vector3.Cross(camera.transform.forward, direction).normalized * width * 0.5f;
        
        Gizmos.DrawLine(start - perpendicular, end - perpendicular);
        Gizmos.DrawLine(start + perpendicular, end + perpendicular);
        Gizmos.DrawLine(start - perpendicular, start + perpendicular);
        Gizmos.DrawLine(end - perpendicular, end + perpendicular);
    }
    
    void OnDestroy()
    {
        // 清理编辑模式下创建的材质
        if (!isRuntime && sharedMaterial != null)
        {
            DestroyImmediate(sharedMaterial);
        }
    }
}



// using UnityEngine;
//
// [RequireComponent(typeof(PolygonCollider2D))]
// [RequireComponent(typeof(LineRenderer))]
// public class RuntimePolygonColliderVisualizer : MonoBehaviour
// {
//     [Header("Visual Settings")]
//     public Color outlineColor = new Color(1, 0.5f, 0, 0.8f); // 橙色
//     [Range(0.01f, 1f)] public float lineThickness = 0.1f;
//     public Material lineMaterial;
//     
//     private PolygonCollider2D polygonCollider;
//     private LineRenderer lineRenderer;
//     
//     void Awake()
//     {
//         polygonCollider = GetComponent<PolygonCollider2D>();
//         lineRenderer = GetComponent<LineRenderer>();
//         
//         SetupLineRenderer();
//         UpdateLineRendererPoints();
//     }
//     
//     void OnValidate()
//     {
//         if (polygonCollider == null)
//             polygonCollider = GetComponent<PolygonCollider2D>();
//         
//         if (lineRenderer == null)
//             lineRenderer = GetComponent<LineRenderer>();
//         
//         SetupLineRenderer();
//         UpdateLineRendererPoints();
//     }
//     
//     void SetupLineRenderer()
//     {
//         if (lineRenderer == null) return;
//         
//         // 配置 LineRenderer
//         lineRenderer.startWidth = lineThickness;
//         lineRenderer.endWidth = lineThickness;
//         lineRenderer.loop = true;
//         lineRenderer.useWorldSpace = false;
//         lineRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
//         lineRenderer.receiveShadows = false;
//         
//         if (lineMaterial == null)
//         {
//             // 使用默认的线材质
//             Shader shader = Shader.Find("Sprites/Default");
//             if (shader != null)
//             {
//                 // 在编辑模式下，我们使用共享材质（避免创建实例）
//                 if (!Application.isPlaying)
//                 {
//                     // 使用一个共享的默认材质（注意：这个材质是共享的，修改颜色会影响所有使用该材质的对象）
//                     // 因此，在编辑模式下我们不修改颜色，或者只在运行时修改
//                     lineRenderer.sharedMaterial = new Material(shader);
//                     // 注意：这里我们使用sharedMaterial，所以不会创建实例
//                     // 但是，我们也不设置颜色，因为编辑模式下我们不希望影响其他对象
//                     // 所以，编辑模式下我们可能看不到颜色设置，或者我们可以通过其他方式（如Gizmos）来预览
//                 }
//                 else
//                 {
//                     // 运行时创建新的材质实例
//                     lineRenderer.material = new Material(shader);
//                     lineRenderer.material.color = outlineColor;
//                 }
//             }
//         }
//         else
//         {
//             // 如果指定了材质，使用指定的材质
//             lineRenderer.sharedMaterial = lineMaterial;
//             // 在运行时，我们可能需要为每个对象单独设置颜色，因此创建实例
//             if (Application.isPlaying)
//             {
//                 lineRenderer.material = new Material(lineMaterial);
//                 lineRenderer.material.color = outlineColor;
//             }
//             else
//             {
//                 // 编辑模式下使用共享材质，不修改颜色
//                 lineRenderer.sharedMaterial = lineMaterial;
//             }
//         }
//     }
//     
//     void UpdateLineRendererPoints()
//     {
//         if (polygonCollider == null || lineRenderer == null || polygonCollider.pathCount == 0) 
//             return;
//         
//         // 获取路径点
//         Vector2[] path = polygonCollider.GetPath(0);
//         
//         // 设置 LineRenderer 点数（比路径点多一个用于闭合）
//         lineRenderer.positionCount = path.Length + 1;
//         
//         // 转换点为局部空间
//         Vector3[] positions = new Vector3[path.Length + 1];
//         for (int i = 0; i < path.Length; i++)
//         {
//             positions[i] = path[i];
//         }
//         positions[path.Length] = path[0]; // 闭合多边形
//         
//         lineRenderer.SetPositions(positions);
//     }
//     
//     // 更新颜色
//     void Update()
//     {
//         if (lineRenderer != null)
//         {
//             lineRenderer.startColor = outlineColor;
//             lineRenderer.endColor = outlineColor;
//         }
//     }
// }
